Shareware Grab Bag/Shareware Grab Bag.iso/050/madtrb2.arc/S_INPUT2.INC

Text File | 1986-02-27 | 56.7 KB | 1,274 lines

{ S_INPUT2.INC }

{ *************************************************************************** }
{ *                                                                         * }
{ *                TURBO SCREEN INPUT PRE-PROCESSOR TOOLKIT                 * }
{ *                                                                         * }
{ *               SCROLLING INPUT SUBPROGRAM INCLUDE FILE  #2               * }
{ *                                                                         * }
{ *                             Version  1.07                               * }
{ *                                                                         * }
{ *                                                                         * }
{ *    This is the second include file for the scrolling window page        * }
{ *    module.  This file wust be used in conjunction with the include      * }
{ *    file 'S_Input1.Inc' .                                                * }
{ *                                                                         * }
{ *    Note that further documentation on scrolling input page support can  * }
{ *    be found in the documentation file 'Tsipp.Doc'.                      * }
{ *                                                                         * }
{ *************************************************************************** }



Procedure ShowRowOfInputData(    Row,
                                 CurrentTopMostDataRow,
                                 CurrentLeftMostDataCol,
                                 CurrentRightMostDataCol:Integer);

{ This procedure shows input data for the passed data row number, at a computed
  location within the scrolling window. }

Var
  Col:Integer;                         { column index for printing out input data }
  ScreenCol:Integer;                   { column index for claering out ould entry }

Begin   { ShowRowOfInputData }
  { define a portion of the screen that the data is scrolled in as the active window }
  Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
         TOP_EDGE_OF_INNER_SCROLL_WINDOW,
         RightEdgeOfInnerScrollWindow,
         BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
  TextColor(ForegroundColor);
  TextBackground(InputWindowColor);
  GotoXY(2,Row-CurrentTopMostDataRow+1);
    Write(Row,'    ');                 { Write row number onto window }
  For Col:=1 To (CurrentRightMostDataCol-CurrentLeftMostDataCol+1) Do
    Begin                              { fill scrolling window row with input data }
      GotoXY((Col*COL_WIDTH)+1,Row-CurrentTopMostDataRow+1);
        For ScreenCol:=1 To MAX_SIZE_OF_S_I_ENTRY Do { clear old entry }
          Write(' ');
      GotoXY((Col*COL_WIDTH)+1,Row-CurrentTopMostDataRow+1);
        Write(S_I_Data[(CurrentLeftMostDataCol+Col-1),Row,S_I_Page]^); { write new entry }
    End; { For Col }
End;    { ShowRowOfInputData }



Procedure Show_S_I_EmptyEntry(    NewCol,
                                  NewRow,
                                  CurrentTopMostDataRow,
                                  CurrentLeftMostDataCol,
                                  CurrentRightMostDataCol:Integer);

{ This procedure prints out the proper sized reversed video input block
  to show an empty entry at the passed position in the current scrolling
  window. }

Var
  Col:Integer;                         { column index counter used in writing out the input block }

Begin   { Show_S_I_EmptyEntry }
  Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
         TOP_EDGE_OF_INNER_SCROLL_WINDOW,
         RightEdgeOfInnerScrollWindow,
         BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
  TextColor(BlockForegroundColor);
  TextBackground(BlockBackgroundColor);
  GotoXY(((NewCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,NewRow-CurrentTopMostDataRow+1);
  For Col:=1 To MAX_SIZE_OF_S_I_ENTRY Do { write out reversed video input block }
    Write(' ');
  GotoXY(((NewCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,NewRow-CurrentTopMostDataRow+1); { goto front of input block }
End;    { Show_S_I_EmptyEntry }



Procedure Show_S_I_CharEntry(    LegalChar:Char);

{ This procedure prints the passed legal character entry in the current
  reversed video data input block. }

Begin   { Show_S_I_CharEntry }
  TextColor(CharacterInputColor);
  TextBackground(InputWindowColor);
  Write(LegalChar);
End;    { Show_S_I_CharEntry }



Procedure MoveScrollWindowInputBlockModule(    OldCol,
                                               OldRow,
                                               NewCol,
                                               NewRow,
                                               CurrentTopMostDataRow,
                                               CurrentLeftMostDataCol,
                                               CurrentRightMostDataCol:Integer);

{ *************************************************************************** }
{ *                                                                         * }
{ *                MOVE SCROLLING WINDOW INPUT BLOCK MODULE                 * }
{ *                                                                         * }
{ *     This module controls the movement of the highlighted prompt and     * }
{ *     input block using the passed OldCol, Oldrow position and passed     * }
{ *     NewCol, NewRow position for the current scrolling input page.       * }
{ *                                                                         * }
{ *************************************************************************** }



  Procedure ShowInputPrompt(    InputCol,
                                InputRow,
                                PromptColor,
                                PromptBackground,
                                BlockColor,
                                BlockBackground:Integer);

  { This procedure is used exclusively to highlight the current column and row
    prompts and input block and also to de-highlight the previous column and
    row prompts and input block in the scrolling window. }

  Var
    Col:Integer;                       { column index counter used in erasing old input data entries }

  Begin   { ShowInputPrompt }

    { define a portion of the screen that the data is scrolled in as the active window }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW,
           RightEdgeOfInnerScrollWindow,
           BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
    TextColor(ForegroundColor);
    TextBackground(InputWindowColor);

    { remove old data entry }
    GotoXY(((InputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,InputRow-CurrentTopMostDataRow+1);
      For Col:=1 To MAX_SIZE_OF_S_I_ENTRY Do
        Write(' ');

    { rewrite row prompt }
    TextColor(PromptColor);
    TextBackground(PromptBackground);
    GotoXY(2,InputRow-CurrentTopMostDataRow+1);
      Write(InputRow,'    ');

    { define a portion of the screen that the data is scrolled in as the active window }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
           RightEdgeOfOuterScrollWindow,
           BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);

  { rewrite column prompt, this routine assumes that there are only 3 lines to each column heading }
    GotoXY(((InputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,2);  { Input entry heading }
      Write(S_I_Pages[S_I_Page].Prompts[InputCol+1].Prompt1);
    GotoXY(((InputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,3);  { Input entry heading }
      Write(S_I_Pages[S_I_Page].Prompts[InputCol+1].Prompt2);
    GotoXY(((InputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,4);  { Input entry heading }
      Write(S_I_Pages[S_I_Page].Prompts[InputCol+1].Prompt3);

    { define a portion of the screen that the data is scrolled in as the active window }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW,
           RightEdgeOfInnerScrollWindow,
           BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
    TextColor(BlockColor);
    TextBackground(BlockBackground);

    { show new data entry }
    GotoXY(((InputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,InputRow-CurrentTopMostDataRow+1); { goto front of data entry }
      If S_I_Data[InputCol,InputRow,S_I_Page]^='' Then
        For Col:=1 To MAX_SIZE_OF_S_I_ENTRY Do
          Write(' ')                   { write reversed video input block }
      Else
        Write(S_I_Data[InputCol,InputRow,S_I_Page]^); { write data entry }

  End;    { ShowInputPrompt }



Begin   { MoveScrollWindowInputBlockModule }
  ShowInputPrompt(OldCol,              { de-highlight old input prompt and corresponding input entry }
                  OldRow,
                  ForegroundColor,
                  InputWindowColor,
                  ForegroundColor,
                  InputWindowColor);
  ShowInputPrompt(NewCol,              { highlight new input prompt and corresponding input entry }
                  NewRow,
                  HighlightColor,
                  InputWindowColor,
                  InputWindowColor,
                  ForegroundColor);
  HighlightSpecial_S_I_Prompts(CurrentLeftMostDataCol,
                               CurrentRightMostDataCol);
End;    { MoveScrollWindowInputBlockModule }



Procedure  Draw_S_I_PagesModule(    CurrentTopMostDataRow,
                                    CurrentLeftMostDataCol,
                                    CurrentRightMostDataCol:Integer);

{ *************************************************************************** }
{ *                                                                         * }
{ *                    DRAW SCROLLING INPUT PAGES MODULE                    * }
{ *                                                                         * }
{ *    This module controls the drawing of the scrolling input pages.       * }
{ *    Note that the case statement below only supports 4 general input     * }
{ *    pages, but this can easily be added to inorder for this module to    * }
{ *    support additional scrolling input pages.                            * }
{ *                                                                         * }
{ *    Note that within this module there is an example procedure that      * }
{ *    was used during program development to construct a screen page.      * }
{ *    Later, the screen pages are read from screen files and stored in the * }
{ *    heap for more rapid display.                                         * }
{ *                                                                         * }
{ *************************************************************************** }



  Procedure DrawScrollingInputWindow;

  { This procedure draws the scrolling input window onto the scrolling input
    pages.  Note that the case statement below only supports 4 scrolling input
    pages, but can easily be added to inorder to support additional scrolling
    input pages. }

  Var
    Col:Integer;                       { a column index counter used in displaying column prompts }

  Begin   { DrawScrollingInputWindow }
    TextColor(InputWindowBorderColor);
    TextBackground(InputWindowColor);
    Case S_I_Page Of
      1 : Begin
            DrawWindow2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                        RightEdgeOfOuterScrollWindow,
                        BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
            DrawHorizWindowLine2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_INNER_SCROLL_WINDOW-1,
                        RightEdgeOfOuterScrollWindow);
          End; { page 1 }
      2 : Begin
            DrawWindow2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                        RightEdgeOfOuterScrollWindow,
                        BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
            DrawHorizWindowLine2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_INNER_SCROLL_WINDOW-1,
                        RightEdgeOfOuterScrollWindow);
          End; { page 2 }
      3 : Begin
            DrawWindow2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                        RightEdgeOfOuterScrollWindow,
                        BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
            DrawHorizWindowLine2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_INNER_SCROLL_WINDOW-1,
                        RightEdgeOfOuterScrollWindow);
          End; { page 3 }
      4 : Begin
            DrawWindow2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                        RightEdgeOfOuterScrollWindow,
                        BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
            DrawHorizWindowLine2(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                        TOP_EDGE_OF_INNER_SCROLL_WINDOW-1,
                        RightEdgeOfOuterScrollWindow);
          End; { page 4 }
    End; { Case Page }
    { routine to display column headings, this routine assumes that there are only 3 lines to each column heading }
    TextColor(ForegroundColor);
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
           RightEdgeOfOuterScrollWindow,
           BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
    For Col:=MAX_LEFT_COL To CurrentRightMostDataCol-CurrentLeftMostDataCol+2 Do
      Begin
        GotoXY(((Col-1)*COL_WIDTH)+1,2);
          Write(S_I_Pages[S_I_Page].Prompts[Col].Prompt1);
        GotoXY(((Col-1)*COL_WIDTH)+1,3);
          Write(S_I_Pages[S_I_Page].Prompts[Col].Prompt2);
        GotoXY(((Col-1)*COL_WIDTH)+1,4);
          Write(S_I_Pages[S_I_Page].Prompts[Col].Prompt3);
      End; { For Col }
  End;    { DrawScrollingInputWindow }



  Procedure Display_S_I_Data;

  { This procedure fills the initially empty scrolling input data window for
    the current S_I_Page with input data. }

  Var
    Row:Integer;                       { index to a data input row }

  Begin   { Display_S_I_Data }
    For Row:=1 To BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW+1 Do
      ShowRowOfInputData(Row,
                         CurrentTopMostDataRow,
                         CurrentLeftMostDataCol,
                         CurrentRightMostDataCol);
  End;    { Display_S_I_Data }



  Procedure Draw_S_I_Pages01to04;

  { This procedure was used during program development to construct the screen
    page.  The screen page is now stored in a screen file and thus the
    application program does not really need this code any longer.  The screen
    page is read from a file and stored in the heap for rapid display.

    You may want to write a similar procedure during your application program
    development. }

  Var
    Page:String[2];                    { string variable used to store the converted page number }
    TextString:WorkString;             { string variable used in passing text to another procedure }

  Begin   { Draw_S_I_Pages01to04 }
    TextColor(ForegroundColor);
    TextBackground(BackgroundColor);
    DrawWindow2(1,1,80,25);

    { place menu on bottom portion of screen pertaining to proper page }
    If S_I_Page=4 Then
      Begin
        TextString:='PgUp   '+Chr(27)+'   '+Chr(26)+'   '+Chr(24)+'   '+Chr(25)+'   Del   Esc';
        WriteCenterText(25,TextString);
      End
    Else
      Begin
        TextString:='PgUp   PgDn   '+Chr(27)+'   '+Chr(26)+'   '+Chr(24)+'   '+Chr(25)+'   Del   Esc';
        WriteCenterText(25,TextString);
      End; { Else }

    { place heading at top of screen }
    TextColor(HighlightColor);
    Case S_I_Page Of
      1 : WriteCenterText(1,'UNIFORM LOADINGS ON MEMBER');
      2 : WriteCenterText(1,'POINT LOADINGS ON MEMBER');
      3 : WriteCenterText(1,'PRISMATIC LOADINGS ON MEMBER');
      4 : WriteCenterText(1,'APPLIED MOMENTS ON MEMBER');
    End; { Case Page }

    TextColor(ForegroundColor);
    DrawSimpleBeam;                    { specific to the example application of the input pre-processor }
    DrawScrollingInputWindow;
    HighlightSpecial_S_I_Prompts(CurrentLeftMostDataCol,
                                 CurrentRightMostDataCol);
    Str(S_I_Page,Page);
    If S_I_Page<=9 Then
      Page:='0'+Page;
(*  WriteScreenPageToFile('S_I_'+Page); { write the screen page off to a screen file } *)
  End;    { Draw_S_I_Pages01to04 }


Begin   { Draw_S_I_PagesModule }
  Case S_I_Page Of
    1 : Begin
(*        Draw_S_I_Pages01to04;        { this line was used during program development } *)
          DisplayScreenPage(S_I_Pages[S_I_Page].Image); { display screen page that is stored in the heap }
        End; { page 1 }
    2 : Begin
(*        Draw_S_I_Pages01to04;        { this line was used during program development } *)
          DisplayScreenPage(S_I_Pages[S_I_Page].Image); { display screen page that is stored in the heap }
        End; { page 2 }
    3 : Begin
(*        Draw_S_I_Pages01to04;        { this line was used during program development } *)
          DisplayScreenPage(S_I_Pages[S_I_Page].Image); { display screen page that is stored in the heap }
        End; { page 3 }
    4 : Begin
(*        Draw_S_I_Pages01to04;        { this line was used during program development } *)
          DisplayScreenPage(S_I_Pages[S_I_Page].Image); { display screen page that is stored in the heap }
        End; { page 4 }
  End; { Case S_I_Page }

  DisplayBeamLength;                   { specific to example application of the input pre-processor }

  Display_S_I_Data;
  MoveScrollWindowInputBlockModule(1,  { place input block at first entry }
                                   1,
                                   1,
                                   1,
                                   CurrentTopMostDataRow,
                                   CurrentLeftMostDataCol,
                                   CurrentRightMostDataCol);

  DisplayBeamLoadModule(1,1);          { specific to example application of the input pre-processor }

End;    { Draw_S_I_PageModule }



Procedure Check_S_I_CharEntryModule(    NewCol,
                                        NewRow,
                                        CurrentTopMostDataRow,
                                        CurrentLeftMostDataCol,
                                        CurrentRightMostDataCol:Integer;
                                    Var AccumDataEntry       :WorkString;
                                        CharEntry            :Char);

{ *************************************************************************** }
{ *                                                                         * }
{ *          CHECK SCROLLING INPUT PAGE CHARACTER INPUT ENTRY MODULE        * }
{ *                                                                         * }
{ *   This module checks the passed CharEntry character and checks to see   * }
{ *   that it is a legal character for the passed input entry location      * }
{ *   If CharEntry is legal then this module adds the CharEntry to the      * }
{ *   passed AccumDataEntry (accumulated data entry string).  If CharEntry  * }
{ *   is not legal then this module ignores the passed character and sounds * }
{ *   an error to identify that the user has keystroked in an illegal       * }
{ *   character.                                                            * }
{ *                                                                         * }
{ *   This module begins by first checking to see if the accumulated data   * }
{ *   entry length is less than the maximum allowed length.  Finally the    * }
{ *   module checks that to see if the single character that has been       * }
{ *   entered is of the type allowed.                                       * }
{ *                                                                         * }
{ *   A list of different input data types this module can check for        * }
{ *   follows:                                                              * }
{ *                                                                         * }
{ *         Input                                                           * }
{ *         Data                                                            * }
{ *         Type                                                            * }
{ *         Value       Description of Input Data Type                      * }
{ *         -----       -----------------------------------------           * }
{ *           1         Positive Integer ( including zero )                 * }
{ *           2         Negative Integer ( including zero )                 * }
{ *           3         Integer                                             * }
{ *           4         Positive Real ( including zero )                    * }
{ *           5         Negative Real ( including zero )                    * }
{ *           6         Real                                                * }
{ *           7         Data File Name                                      * }
{ *           8         Disk Drive Subdirectory Path                        * }
{ *           9         General                                             * }
{ *                                                                         * }
{ *************************************************************************** }


Type
  CharSet=Set Of Char;                 { a set of legal characters used for checking the character entry }

Var
  LegalCharSet:CharSet;                { a variable used for storing the set of legal characters }



  Procedure DetermineLegalCharSet(    DataType    :Integer;
                                      DataEntry   :WorkString;
                                  Var LegalCharSet:CharSet);

  { This procedure determines the legal set of characters for the current data
    entry by looking at the passed DataType value. }

  Var
    DecimalOccurrence:Boolean;         { boolean used to test for the occurence of a decimal point in the passed string }

  Begin   { DetermineLegalCharSet }
    DecimalOccurrence:=(Pos('.',DataEntry)<>0); { If true then decimal point is contained within data entry }
    Case DataType Of
      1 : Begin { Positive Integer }
            LegalCharSet:=['0'..'9'];
          End;  { Positive Integer }
      2 : Begin { Negative Integer }
            If Length(DataEntry)=0 Then
              LegalCharSet:=['-']
            Else
              LegalCharSet:=['0'..'9'];
          End;  { Negative Integer }
      3 : Begin { Integer }
            If Length(DataEntry)=0 Then
              LegalCharSet:=['-','0'..'9']
            Else
              LegalCharSet:=['0'..'9'];
          End;  { Integer }
      4 : Begin { Positive Real }
            If DecimalOccurrence Then
              LegalCharSet:=['0'..'9']
            Else
              LegalCharSet:=['.','0'..'9'];
          End;  { Positive Real }
      5 : Begin { Negative Real }
            If Length(DataEntry)=0 Then
              LegalCharSet:=['-']
            Else
              If DecimalOccurrence Then
                LegalCharSet:=['0'..'9']
              Else
                LegalCharSet:=['.','0'..'9'];
          End;  { Negative Real }
      6 : Begin { Real }
            If Length(DataEntry)=0 Then
              LegalCharSet:=['-','.','0'..'9']
            Else
              If DecimalOccurrence Then
                LegalCharSet:=['0'..'9']
              Else
                LegalCharSet:=['.','0'..'9'];
          End;  { Real }
      7 : Begin { Data File Name }
            LegalCharSet:=['A'..'Z','a'..'z','0'..'9','_','-','!','@','#','$',
                           '%','&'];
          End;  { Data File Name }
      8 : Begin { Disk Drive Subdirectory Path }
            LegalCharSet:=['A'..'Z','a'..'z','0'..'9','_','-','!','@','#','$',
                           '%','&','\',':'];
          End;  { Disk Drive Subdirectory Path }
      9 : Begin { General }
            LegalCharSet:=['A'..'Z','a'..'z','0'..'9','`','~','!','@','#','$',
                           '%','^','&','*','(',')','-','_','=','+','\','|','[',
                           '{',']','}',';',':','"',',','<','.','>','/','?',' '];
          End;  { General }
    End; { Case DataType }
  End;    { DetermineLegalCharSet }



Begin   { Check_S_I_CharEntryModule }
  If Length(AccumDataEntry)<MAX_SIZE_OF_S_I_ENTRY Then { check length of accumulated data entry }
    Begin                              { accumulated character entry length less than maximum allowable length }
      DetermineLegalCharSet(S_I_Pages[S_I_Page].Prompts[NewCol+1].InputDataType,
                            AccumDataEntry,
                            LegalCharSet);
      If CharEntry In LegalCharSet Then
        Begin { legal character entry, add to accumulated data entry }
          AccumDataEntry:=AccumDataEntry+CharEntry;
          If Length(AccumDataEntry)=1 Then
            Show_S_I_EmptyEntry(NewCol, { procedure call overwrites the old entry }
                                NewRow,
                                CurrentTopMostDataRow,
                                CurrentLeftMostDataCol,
                                CurrentRightMostDataCol);
          Show_S_I_CharEntry(CharEntry);
        End { If CharEntry }
      Else { illegal character entry }
        SoundError;
    End { If Length(AccumDataEntry) }
  Else { allowable length of accumulated character entry has been reached, no more entry of characters allowed }
    SoundError;
End;    { Check_S_I_CharEntryModule }



Procedure Special_S_I_CharEntryModule(Var OldCol                 :Integer;
                                          OldRow                 :Integer;
                                      Var NewCol                 :Integer;
                                          NewRow,
                                          CurrentTopMostDataRow  :Integer;
                                      Var CurrentLeftMostDataCol,
                                          CurrentRightMostDataCol:Integer;
                                          CharEntry              :Char);

{ *************************************************************************** }
{ *                                                                         * }
{ *            SPECIAL SCROLLING INPUT PAGE CHARACTER ENTRY MODULE          * }
{ *                                                                         * }
{ *    There may be specific input data entries that have been defined to   * }
{ *    have 2, 3, or more special characters as input.  This module checks  * }
{ *    for the entry of these special characters.                           * }
{ *                                                                         * }
{ *    Note that the case statement below only supports 4 scrolling input   * }
{ *    pages, but this can easily be added to inorder for this module to    * }
{ *    support additional scrolling input pages.                            * }
{ *                                                                         * }
{ *    Note that the procedures within this module have been written        * }
{ *    specifically for the example application of the input pre-processor. * }
{ *    You may want to write similar procedures for your application.       * }
{ *                                                                         * }
{ *************************************************************************** }



  Procedure DetermineLoadType(    Entry:Char);

  { This procedure is specific to the example application of the input
    pre-processor.  This procedure allows the user to enter a special quick
    character input entry.  You may want to write a similar procedure for
    your application.

    This procedure determines the loading type the user has selected for this
    particular loading data entry.  The following load types are available:

              Initial
              Construction
              Dead
              Live                               }

  Begin   { DetermineLoadType }
    OldCol:=NewCol;
    OldRow:=NewRow;
    If Entry In ['I','i','C','c','D','d','L','l'] Then { determine if a legal character was entered }
      Begin { legal character entry }
        Case Entry Of
          'I','i' : Begin { Initial Loading }
                      S_I_Data[NewCol,NewRow,S_I_Page]^:='INITIAL';
                    End;  { Initial Loading }
          'C','c' : Begin { Construction Loading }
                      S_I_Data[NewCol,NewRow,S_I_Page]^:='CONSTR.';
                    End;  { Construction Loading }
          'D','d' : Begin { Dead Loading }
                      S_I_Data[NewCol,NewRow,S_I_Page]^:='DEAD';
                    End;  { Dead Loading }
          'L','l' : Begin { Live Loading }
                      S_I_Data[NewCol,NewRow,S_I_Page]^:='LIVE';
                    End;  { Live Loading }
        End; { Case Entry }
        NewCol:=NewCol+1;
        If NewCol>CurrentRightMostDataCol Then
          ShiftScrollWindowDataSidewaysModule(NewCol,
                                              CurrentTopMostDataRow,
                                              CurrentLeftMostDataCol,
                                              CurrentRightMostDataCol);
        { following routine handles special case when only one data column is displayed in the scrolling window }
        If CurrentLeftMostDataCol=CurrentRightMostDataCol Then
          OldCol:=NewCol;
        MoveScrollWindowInputBlockModule(OldCol,
                                         OldRow,
                                         NewCol,
                                         NewRow,
                                         CurrentTopMostDataRow,
                                         CurrentLeftMostDataCol,
                                         CurrentRightMostDataCol);

        DisplayBeamLoadModule(NewCol,NewRow); { specific to example application of the input pre-processor }

      End { If Ord(Entry) }
    Else { illegal character entry }
        SoundError;
  End;    { DetermineLoadType }



Begin   { Special_S_I_CharEntryModule }
  Case S_I_Page Of
    1 : Begin
          DetermineLoadType(CharEntry);
        End; { page 1 }
    2 : Begin
          DetermineLoadType(CharEntry);
        End; { page 2 }
    3 : Begin
          DetermineLoadType(CharEntry);
        End; { page 3 }
    4 : Begin
          DetermineLoadType(CharEntry);
        End; { page 4 }
  End; { Case G_I_Page }
End;    { Special_S_I_CharEntryModule }



Procedure S_I_EntryModule;

{ *************************************************************************** }
{ *                                                                         * }
{ *                    SCROLLING INPUT PAGES ENTRY MODULE                   * }
{ *                                                                         * }
{ *   This module controls the user's input for the scrolling input pages.  * }
{ *   This module passes control to specific procedures within if a screen  * }
{ *   command is called upon.                                               * }
{ *                                                                         * }
{ *************************************************************************** }



Var
    OldInputCol:Integer;               { column index to the previously highlighted input block }
    OldInputRow:Integer;               { row index to the previously highlighted input block }

    CurrentInputCol:Integer;           { column index to the current highlighted input block }
    CurrentInputRow:Integer;           { row index to the current highlighted input block }

    CurrentTopMostDataRow:Integer;     { used to identify the current data row number for the data }
                                       { at the topmost row of the current scrolling input window }
    CurrentLeftMostDataCol:Integer;    { used to identify the current data column number for the data }
                                       { at the leftmost column of the current scrolling input window }
    CurrentRightMostDataCol:Integer;   { used to identify the current data column number for the data }
                                       { at the rightmost column of the current scrolling input window }

    ExitModule:Boolean;                { flag used in determining when to exit this input module }



  Procedure Init_S_I_Variables;

  { This procedure initializes the S_I_Page module's variables. Note that the
    case statement below only supports 4 scrolling input pages, but can easily
    be added to inorder to support additional pages. }

  Begin   { Init_S_I_Variables }
    OldInputCol:=1;
    OldInputRow:=1;
    CurrentInputCol:=1;
    CurrentInputRow:=1;
    CurrentTopMostDataRow:=1;
    Case S_I_Page Of
      1 : Begin
            CurrentLeftMostDataCol:=1;
            CurrentRightMostDataCol:=3; { 3 data columns displayed in scrolling window }
          End; { page 1 }
      2 : Begin
            CurrentLeftMostDataCol:=1;
            CurrentRightMostDataCol:=1; { 1 data column displayed in scrolling window }
          End; { page 2 }
      3 : Begin
            CurrentLeftMostDataCol:=1;
            CurrentRightMostDataCol:=6; { 6 data columns displayed in scrolling window }
          End; { page 3 }
      4 : Begin
            CurrentLeftMostDataCol:=1;
            CurrentRightMostDataCol:=3; { 3 data columns displayed in scrolling window }
          End; { page 4 }
    End; { Case S_I_Page }
    ExitModule:=False;
  End;    { Init_S_I_Variables }



  Procedure Escape;

  { This procedure controls the entry of a escape command.  Note that upon
    issuing the escape command the user is signaling that he wants to exit the
    input pre-processor.  Before exiting the pre-processor the user is queried
    if he wants to save the data he has entered.

    Note that the case statement below only supports 4 scrolling input pages,
    but can easily be added to inorder to support additional pages. }

  Begin   { Escape }
    Case S_I_Page Of
      1 : Begin
            WriteInputFileModule(ExitModule); { if passed boolean returns true, then exit this module }
          End; { page 1 }
      2 : Begin
            WriteInputFileModule(ExitModule); { if passed boolean returns true, then exit this module }
          End; { page 2 }
      3 : Begin
            WriteInputFileModule(ExitModule); { if passed boolean returns true, then exit this module }
          End; { page 3 }
      4 : Begin
            WriteInputFileModule(ExitModule); { if passed boolean returns true, then exit this module }
          End; { page 4 }
    End; { Case S_I_Page }
    If ExitModule Then
      Begin { return to MainModule and then to first menu page }
        MenuPage:=1;
        CurrentPage:=Menu;
      End; { If ExitModule }
  End;    { Escape }



  Procedure PageUp;

  { This procedure controls the entry of a page up command.  Note that the case
    statement below only supports 4 scrolling input pages, but can easily be
    added to inorder to support additional pages. }

  Begin   { PageUp }
    Case S_I_Page Of
      1 : Begin
            CurrentPage:=G_I;
            G_I_Page:=1;
            ExitModule:=True;
          End; { page 1 }
      2 : Begin
            CurrentPage:=S_I;
            S_I_Page:=1;
            ExitModule:=True;
          End; { page 2 }
      3 : Begin
            CurrentPage:=S_I;
            S_I_Page:=2;
            ExitModule:=True;
          End; { page 3 }
      4 : Begin
            CurrentPage:=S_I;
            S_I_Page:=3;
            ExitModule:=True;
          End; { page 4 }
    End; { Case S_I_Page }
  End;    { PageUp }



  Procedure PageDown;

  { This procedure controls the entry of a page down command. Note that the
    case statement below only supports 4 scrolling input pages, but can easily
    be added to inorder for this module to support additional pages. }

  Begin   { PageDown }
    Case S_I_Page Of
      1 : Begin
            CurrentPage:=S_I;
            S_I_Page:=2;
            ExitModule:=True;
          End; { page 1 }
      2 : Begin
            CurrentPage:=S_I;
            S_I_Page:=3;
            ExitModule:=True;
          End; { page 2 }
      3 : Begin
            CurrentPage:=S_I;
            S_I_Page:=4;
            ExitModule:=True;
          End; { page 3 }
      4 : Begin
            SoundError;
          End; { page 4 }
    End; { Case S_I_Page }
  End;    { PageDown }



  Procedure CurseUp;

  { This procedure controls the cursor's upward movement in the scrolling
    window.  If the input block is at the top of the scrolling window, this
    procedure scrolls the window's data entries down one row by inserting a
    blank line at the top of the scrolling window.  It then writes in the data
    entry for that particular row and moves the input block to the new entry
    location.

    Before the above cursor movement is allowed the procedure checks to make
    certain that the input block is not at the top row of data entries the
    window views upon. }

  Begin   { CurseUp }
    TextColor(ForegroundColor);
    TextBackground(InputWindowColor);
    If CurrentInputRow=1 Then
      SoundError                       { at top of all the entries the window views upon }
    Else
      Begin                            { legal move }
        If CurrentInputRow=CurrentTopMostDataRow Then
          Begin { at top of scrolling window, need to scroll data in the window downward inorder to curse upward }
            { define a portion of the screen that the data is scrolled in as the active window }
            Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
                   TOP_EDGE_OF_INNER_SCROLL_WINDOW,
                   RightEdgeOfInnerScrollWindow,
                   BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
            GotoXY(1,1);
            InsLine; { insert a blank line at top of the scrolling window }
            CurrentTopMostDataRow:=CurrentTopMostDataRow-1; { redefine top row of data to be displayed in
              scrolling window }
            ShowRowOfInputData(CurrentInputRow-1, { display new top row of data }
                               CurrentTopMostDataRow,
                               CurrentLeftMostDataCol,
                               CurrentRightMostDataCol);
          End; { If CurrentInputRow }
        OldInputCol:=CurrentInputCol;
        OldInputRow:=CurrentInputRow;
        CurrentInputRow:=CurrentInputRow-1;  { de-increment current data row }
        MoveScrollWindowInputBlockModule(OldInputCol,
                                         OldInputRow,
                                         CurrentInputCol,
                                         CurrentInputRow,
                                         CurrentTopMostDataRow,
                                         CurrentLeftMostDataCol,
                                         CurrentRightMostDataCol);

        DisplayBeamLoadModule(CurrentInputCol,CurrentInputRow); { specific to the example application of the pre-processor }

      End; { Else }
  End;    { CurseUp }



  Procedure CurseDown;

  { This procedure controls the cursor's downward movement in the scrolling
    window.  If the input block is at the bottom of the scrolling window this
    procedure scrolls the window's data entries up one row by writing the data
    entry for the next row at the bottom of the active window.

    Before the above cursor movement is allowed the procedure checks to make
    certain that the input block is not at the bottom row of data entries the
    window views upon. }

  Begin   { CurseDown }
    TextColor(ForegroundColor);
    TextBackground(InputWindowColor);
    If CurrentInputRow=S_I_ENTRY_LIMIT Then
      SoundError                       { at bottom of all entries the window views upon }
    Else
      Begin                            { legal move }
        If CurrentInputRow=CurrentTopMostDataRow+BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW Then
          Begin { at bottom of scrolling window, need to scroll data in the window upward inorder to curse downward }
            { define a portion of the screen that the data is scrolled in as the active window }
            Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
                   TOP_EDGE_OF_INNER_SCROLL_WINDOW,
                   RightEdgeOfInnerScrollWindow,
                   BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
            GotoXY(1,BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW+1);
            WriteLn;
            CurrentTopMostDataRow:=CurrentTopMostDataRow+1; { redefine top row of data to be displayed in
              scrolling window }
            ShowRowOfInputData(CurrentInputRow+1, { display new bottom row of data }
                               CurrentTopMostDataRow,
                               CurrentLeftMostDataCol,
                               CurrentRightMostDataCol);

          End; { If CurrentInputRow }
        OldInputCol:=CurrentInputCol;
        OldInputRow:=CurrentInputRow;
        CurrentInputRow:=CurrentInputRow+1; { increment current data row }
        MoveScrollWindowInputBlockModule(OldInputCol,
                                         OldInputRow,
                                         CurrentInputCol,
                                         CurrentInputRow,
                                         CurrentTopMostDataRow,
                                         CurrentLeftMostDataCol,
                                         CurrentRightMostDataCol);

        DisplayBeamLoadModule(CurrentInputCol,CurrentInputRow); { specific to the example application of the pre-processor }

      End; { Else }
  End;    { CurseDown }



  Procedure CurseLeft;

  { This procedure controls the cursor's leftward movement in the current
    scrolling window. }

  Begin   { CurseLeft }
    If CurrentInputCol<>MAX_LEFT_COL Then
      Begin { legal move }
        OldInputCol:=CurrentInputCol;
        OldInputRow:=CurrentInputRow;
        CurrentInputCol:=CurrentInputCol-1;
        If CurrentInputCol<CurrentLeftMostDataCol Then
          ShiftScrollWindowDataSidewaysModule(CurrentInputCol,
                                              CurrentTopMostDataRow,
                                              CurrentLeftMostDataCol,
                                              CurrentRightMostDataCol);
        { following routine handles special case when only one data column is displayed in the scrolling window }
        If CurrentLeftMostDataCol=CurrentRightMostDataCol Then
          OldInputCol:=CurrentInputCol;
        MoveScrollWindowInputBlockModule(OldInputCol,
                                         OldInputRow,
                                         CurrentInputCol,
                                         CurrentInputRow,
                                         CurrentTopMostDataRow,
                                         CurrentLeftMostDataCol,
                                         CurrentRightMostDataCol);
      End { If CurrentInputCol }
    Else { not a legal move }
      SoundError;
  End;    { CurseLeft }



  Procedure CurseRight;

  { This procedure controls the cursor's rightward movement in the current
    scrolling window. }

  Begin   { CurseRight }
    If CurrentInputCol<>MaxRightCol Then
      Begin { legal move }
        OldInputCol:=CurrentInputCol;
        OldInputRow:=CurrentInputRow;
        CurrentInputCol:=CurrentInputCol+1;
        If CurrentInputCol>CurrentRightMostDataCol Then
          ShiftScrollWindowDataSidewaysModule(CurrentInputCol,
                                              CurrentTopMostDataRow,
                                              CurrentLeftMostDataCol,
                                              CurrentRightMostDataCol);
        { following routine handles special case when only one data column is displayed in the scrolling window }
        If CurrentLeftMostDataCol=CurrentRightMostDataCol Then
          OldInputCol:=CurrentInputCol;
        MoveScrollWindowInputBlockModule(OldInputCol,
                                         OldInputRow,
                                         CurrentInputCol,
                                         CurrentInputRow,
                                         CurrentTopMostDataRow,
                                         CurrentLeftMostDataCol,
                                         CurrentRightMostDataCol);
      End { If CurrentInputCol }
    Else { not a legal move }
      SoundError;
  End;    { CurseRight }



  Procedure DeleteEntry;

  { This procedure controls the deletion of a entry in the current scrolling
    window. }

  Begin   { DeleteEntry }
    S_I_Data[CurrentInputCol,CurrentInputRow,S_I_Page]^:='';
    OldInputCol:=CurrentInputCol;
    OldInputRow:=CurrentInputRow;
    MoveScrollWindowInputBlockModule(OldInputCol,
                                     OldInputRow,
                                     CurrentInputCol,
                                     CurrentInputRow,
                                     CurrentTopMostDataRow,
                                     CurrentLeftMostDataCol,
                                     CurrentRightMostDataCol);

    DisplayBeamLoadModule(CurrentInputCol,CurrentInputRow); { specific to the example application of the pre-processor }

  End;    { DeleteEntry }



  Procedure Backspace(Var AccumCharEntry:Workstring);

  { This procedure removes the last character in the accumulated character
    entry in the current scrolling window. }

  Var
    CharEntry:Char;                    { char variable used to print out the newly shortened input string }
    Col:Integer;                       { column index counter used to print out the newly shortened input string }

  Begin   { Backspace }
    If Length(AccumCharEntry)<>0 Then
      Begin
        Delete(AccumCharEntry,Length(AccumCharEntry),1); { remove last character in the accumulated string entry }
        Show_S_I_EmptyEntry(CurrentInputCol,             { rewrite over old entry with empty input block }
                            CurrentInputRow,
                            CurrentTopMostDataRow,
                            CurrentLeftMostDataCol,
                            CurrentRightMostDataCol);
        For Col:=1 To Length(AccumCharEntry) Do
          Begin                        { re-display newly shortened accumulated string entry }
            CharEntry:=Copy(AccumCharEntry,Col,1);
            Show_S_I_CharEntry(CharEntry);
          End; { For Col }
      End { If Length }
    Else { not able to remove any more characters from empty input data entry }
      SoundError;
  End;    { Backspace }



  Procedure CarriageReturn;

  { This procedure accepts the user's carriage return entry and in response
    moves the reversed video input block to the next entry in the scrolling
    input data window.

    Note that there are seven special cases that this procedure must be able
    to handle:

           1. Move entry block to next entry to the right.
           2. Shift data columns to left in the scroll window inorder to move
              entry block to the next entry to the right.
           3. Entry block at extreme right entry, must move to next line's
              first entry.
           4. Entry block at extreme right entry, must move to next line's
              first entry, but must shift data columns to right to get access
              to the next line's first entry.
           5. Entry block at extreme right entry and bottom of the scrolling
              window.  Need to insert a line at the bottom of the scrolling
              window to be able to access next line's first entry.
           6. Entry block at extreme right entry and bottom of the scrolling
              window.  Need to insert a line at the bottom of the scrolling
              window and shift data columns to the right inorder to access
              the next line's first entry.
           7. At the extreme lower right data entry in the scrolling window
              and cannot move the entry block any further. }

  Begin   { CarriageReturn }
    OldInputCol:=CurrentInputCol;
    OldInputRow:=CurrentInputRow;
    { check for Not Case 7 }
    If Not((CurrentInputCol=MaxRightCol) And (CurrentInputRow=S_I_ENTRY_LIMIT)) Then
      { check for Not Case 1 or 2 }
      If CurrentInputCol=MaxRightCol Then
        Begin { Case 3, 4, 5, & 6 }
          { increment entry col & row indexes }
          CurrentInputCol:=MAX_LEFT_COL;
          CurrentInputRow:=CurrentInputRow+1;
          { check for Case 5 & 6 }
          If CurrentInputRow=CurrentTopMostDataRow+BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW+1 Then
            Begin { Case 5 & 6 }
              { routine inserts a blank line at the bottom of the scroll window, moving all displayed data entries up 1 row }
              TextColor(ForegroundColor);
              TextBackground(InputWindowColor);
              Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW, { define portion of screen data is to be scrolled in }
                     TOP_EDGE_OF_INNER_SCROLL_WINDOW,
                     RightEdgeOfInnerScrollWindow,
                     BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
              GotoXY(1,BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW+1);
              WriteLn; { insert a blank line at screen bottom }
              { redefine top row of data being displayed in the scrolling window }
              CurrentTopMostDataRow:=CurrentTopMostDataRow+1;
              ShowRowOfInputData(CurrentInputRow,
                                 CurrentTopMostDataRow,
                                 CurrentLeftMostDataCol,
                                 CurrentRightMostDataCol);
            End; { Case 5 & 6 }
          { check for Case 4 & 6 }
          If CurrentLeftMostDataCol<>MAX_LEFT_COL Then
            Begin { Case 4 & 6 }
              { following statement prevents attempted removal of old entry block }
              OldInputCol:=CurrentInputCol;
              ShiftScrollWindowDataSidewaysModule(CurrentInputCol,
                                                  CurrentTopMostDataRow,
                                                  CurrentLeftMostDataCol,
                                                  CurrentRightMostDataCol);
            End; { Case 4 & 6 }
        End { Case 3, 4, 5, & 6 }
      Else
        Begin { Case 1 & 2 }
          { increment entry col index }
          CurrentInputCol:=CurrentInputCol+1;
          If CurrentInputCol>CurrentRightMostDataCol Then
            Begin { Case 2 }
              ShiftScrollWindowDataSidewaysModule(CurrentInputCol,
                                                  CurrentTopMostDataRow,
                                                  CurrentLeftMostDataCol,
                                                  CurrentRightMostDataCol);
              { following routine handles special case when only one data column is displayed in the scrolling window }
              If CurrentLeftMostDataCol=CurrentRightMostDataCol Then
                OldInputCol:=CurrentInputCol;
            End; { Case 2 }
        End; { Case 1 & 2 }
    { Case 1 thru 7 }
    MoveScrollWindowInputBlockModule(OldInputCol,
                                     OldInputRow,
                                     CurrentInputCol,
                                     CurrentInputRow,
                                     CurrentTopMostDataRow,
                                     CurrentLeftMostDataCol,
                                     CurrentRightMostDataCol);

    { the following is specific to the example application of the input pre-processor }
    DisplayBeamLoadModule(CurrentInputCol,CurrentInputRow);

  End;    { CarriageReturn }



  Procedure AccumulateEntry(    CharEntry:Char);

  { This procedure controls the accumulation of inputed characters for a data
    entry for the current scrolling input page.  Note that the call to
    Check_S_I_CharEntryModule checks to see if the CharEntry is legal, and if
    so then places the legal character into the AccumDataEntry. }

  Var
    AccumDataEntry:WorkString;         { string variable used for accumulating the data entry }

  Begin   { AccumulateEntry }
    AccumDataEntry:='';                { initialize accumulated keyboard entry }
    ShowBlinkingCursor;
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW,
           RightEdgeOfInnerScrollWindow,
           BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
    { locate at start of data entry }
    GotoXY(((CurrentInputCol-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,CurrentInputRow-CurrentTopMostDataRow+1);
    Check_S_I_CharEntryModule(CurrentInputCol,
                              CurrentInputRow,
                              CurrentTopMostDataRow,
                              CurrentLeftMostDataCol,
                              CurrentRightMostDataCol,
                              AccumDataEntry,
                              CharEntry);
    Repeat
      Read(Kbd,CharEntry);
      If (CharEntry=Chr(27)) And KeyPressed Then  { read illegal double character entry without executing code command }
        Begin
          Read(Kbd,CharEntry);
          SoundError;
        End { If CharEntry }
      Else
        If CharEntry=Chr(8) Then       { backspace }
          Backspace(AccumDataEntry)
        Else
          If CharEntry<>Chr(13) Then   { carriage return }
            Check_S_I_CharEntryModule(CurrentInputCol,
                                      CurrentInputRow,
                                      CurrentTopMostDataRow,
                                      CurrentLeftMostDataCol,
                                      CurrentRightMostDataCol,
                                      AccumDataEntry,
                                      CharEntry);
    Until CharEntry=Chr(13);           { carriage Return }
    HideBlinkingCursor;
    If (AccumDataEntry='.') Or (AccumDataEntry='-') Or (AccumDataEntry='-.') Then
      AccumDataEntry:=''; { remove meaningless entry }
    S_I_ErrorCheckingModule(OldInputCol,
                            OldInputRow,
                            CurrentInputCol,
                            CurrentInputRow,
                            CurrentTopMostDataRow,
                            CurrentLeftMostDataCol,
                            CurrentRightMostDataCol,
                            AccumDataEntry);
    S_I_Data[CurrentInputCol,CurrentInputRow,S_I_Page]^:=AccumDataEntry; { transfer data entry into data structure }
    CarriageReturn;
  End;    { AccumulateEntry }



  Procedure ReadKeyboard;

  { This procedure determines what the user's keyboard entry is.  It passes
    control to specific procedures within this module if a screen command
    dealing with any of the scrolling input pages is called upon. }

  Var
    KeyboardEntry:Char;                { variable used in storing the character read from the keyboard }

  Begin   { ReadKeyboard }
    Read(Kbd,KeyboardEntry);
    If  (KeyboardEntry=Chr(27)) And KeyPressed Then { read a character, check for a double character entry }
      Begin                            { double character entry }
        Read(Kbd,KeyboardEntry);
        Case Ord(KeyboardEntry) Of
          73 : PageUp;
          81 : PageDown;
          72 : CurseUp;
          80 : CurseDown;
          75 : CurseLeft;
          77 : CurseRight;
          83 : DeleteEntry;
        Else { illegal entry }
          SoundError;
        End; { Case Ord(KeyboardEntry) }
      End { If KeyboardEntry }
    Else
      Begin                            { single character entry }
        Case Ord(KeyboardEntry) Of
          13 : CarriageReturn;
          27 : Escape;
        Else
          If CurrentInputCol=1 Then { check for a special character entry }
            Special_S_I_CharEntryModule(OldInputCol,
                                        OldInputRow,
                                        CurrentInputCol,
                                        CurrentInputRow,
                                        CurrentTopMostDataRow,
                                        CurrentLeftMostDataCol,
                                        CurrentRightMostDataCol,
                                        KeyboardEntry)
          Else { accumulate input entry from user }
            AccumulateEntry(KeyboardEntry);
        End; { Case Ord(KeyboardEntry) }
      End; { Else }
  End;    { ReadKeyboard }



Begin   { S_I_EntryModule }
  Init_S_I_Variables;
  Draw_S_I_PagesModule(CurrentTopMostDataRow,
                       CurrentLeftMostDataCol,
                       CurrentRightMostDataCol);
  Repeat
    ReadKeyboard;
  Until ExitModule;
End;    { S_I_EntryModule }